﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;

namespace CreatingObjects3d
{
    [Serializable()]
    public class ObjetoCieloSuelo
    {
        private Color colorSueloHorizonte;
        private Color colorSueloEsfera;
        private Color colorCieloHorizonte;
        private Color colorCieloEsfera;

        public float anguloSuelo;
        public float anguloCielo;

        public ObjetoCieloSuelo()
        {
        }

        /// <summary>
        /// Este es el constructor de la clase ObjetoCieloSuelo. Recibe un valor float para indicar el angulo de la esfera
        /// correspondiente al suelo, otro float para el angulo del cielo y un array de enteros que contiene el RGB del color
        /// del Suelo y el RGB del color del Cielo, tanto en el horizonte como en la esfera.
        /// Hay que indicar el angulo donde se empiezan a degradar los colores el primero para el suelo y el segundo para el cielo.
        /// Los colores se indican de la siguiente forma: Se indican 4 grupos de colores RGB, ColorSuelo en el horizonte, ColorSuelo, ColorCielo en el horizonte,
        /// ColorCielo en el cielo.
        /// </summary>
        /// <param name="anguloSuelo"></param>
        /// <param name="anguloCielo"></param>
        /// <param name="colores"></param>
        public ObjetoCieloSuelo(float anguloSuelo, float anguloCielo, params int[] colores)
        {
            this.anguloSuelo = anguloSuelo;
            this.anguloCielo = anguloCielo;
            colorSueloHorizonte = System.Drawing.Color.FromArgb(colores[0], colores[1], colores[2]);
            colorSueloEsfera = System.Drawing.Color.FromArgb(colores[3], colores[4], colores[5]);
            colorCieloHorizonte = System.Drawing.Color.FromArgb(colores[6], colores[7], colores[8]);
            colorCieloEsfera = System.Drawing.Color.FromArgb(colores[9], colores[10], colores[11]);                        
        }

        #region Metodos Get

        /// <summary>
        /// Devuelve en un array de enteros el color del suelo en el horizonte.
        /// </summary>
        /// <returns></returns>
        public int[] getColorSueloHorizonte()
        {
            int[] arraycolorSuelo = new int[3];
            arraycolorSuelo[0] = colorSueloHorizonte.R;
            arraycolorSuelo[1] = colorSueloHorizonte.G;
            arraycolorSuelo[2] = colorSueloHorizonte.B;
            return arraycolorSuelo;
        }

        /// <summary>
        /// Devuelve en un array de enteros el color que tendrá el suelo en la parte de abajo.
        /// </summary>
        /// <returns></returns>
        public int[] getColorSueloEsfera()
        {
            int[] arraycolorSuelo = new int[3];
            arraycolorSuelo[0] = colorSueloEsfera.R;
            arraycolorSuelo[1] = colorSueloEsfera.G;
            arraycolorSuelo[2] = colorSueloEsfera.B;
            return arraycolorSuelo;
        }

        /// <summary>
        /// Metodo público que devuelve el color del cielo en el horizonte utilizando un array de enteros.
        /// </summary>
        /// <returns></returns>
        public int[] getColorCieloHorizonte()
        {
            int[] arrayColorCielo = new int[3];
            arrayColorCielo[0] = colorCieloHorizonte.R;
            arrayColorCielo[1] = colorCieloHorizonte.G;
            arrayColorCielo[2] = colorCieloHorizonte.B;
            return arrayColorCielo;
        }

        /// <summary>
        /// Devuelve, en un array de enteros el color del cielo en la parte superior.
        /// </summary>
        /// <returns></returns>
        public int[] getColorCieloEsfera()
        {
            int[] arrayColorCielo = new int[3];
            arrayColorCielo[0] = colorCieloEsfera.R;
            arrayColorCielo[1] = colorCieloEsfera.G;
            arrayColorCielo[2] = colorCieloEsfera.B;
            return arrayColorCielo;
        }

        #endregion Metodos Get

        #region Metodos Set

        /// <summary>
        /// Metodo que establece el color del suelo en el horizonte. Recibe como parámetros 3 enteros
        /// correspondientes a los colores rojo - R, verde G, y azul B.
        /// </summary>
        /// <param name="red"></param>
        /// <param name="green"></param>
        /// <param name="blue"></param>
        public void setColorSueloHorizonte(int red, int green, int blue)
        {
            colorSueloHorizonte = System.Drawing.Color.FromArgb(red, green, blue);           
        }

        /// <summary>
        /// Recibe 3 parámetros que establecen la cantidad de rojo, verde y azul que tendrá el suelo en su parte inferior.
        /// </summary>
        /// <param name="red"></param>
        /// <param name="green"></param>
        /// <param name="blue"></param>
        public void setColorSueloEsfera(int red, int green, int blue)
        {
            colorSueloEsfera = System.Drawing.Color.FromArgb(red, green, blue);           
        }

        /// <summary>
        /// Metodo que establece el color del cielo en el horizonte en base a tres enteros (R, G y B) que recibe como parámetros.
        /// </summary>
        /// <param name="red"></param>
        /// <param name="green"></param>
        /// <param name="blue"></param>
        public void setColorCieloHorizonte(int red, int green, int blue)
        {
            colorCieloHorizonte = System.Drawing.Color.FromArgb(red, green, blue);            
        }

        /// <summary>
        /// Establece la cantidad de rojo, verde y azul que tendrá el color del cielo en su parte superior.
        /// </summary>
        /// <param name="red"></param>
        /// <param name="green"></param>
        /// <param name="blue"></param>
        public void setColorCieloEsfera(int red, int green, int blue)
        {
            colorCieloEsfera = System.Drawing.Color.FromArgb(red, green, blue);            
        }

        #endregion Metodos Set

        #region Metodos Get y Set C#

        /// <summary>
        /// Devuelve o establece el angulo (en radianes) que delimita el color del suelo en su parte inferior con
        /// el color que éste tendrá en el horizonte.
        /// </summary>
        public float AnguloSuelo
        {
            get { return anguloSuelo; }
            set { anguloSuelo = value; }
        }

        /// <summary>
        /// Devuelve o establece el angulo que determina el limite de aplicación de los colores del cielo, es decir,
        /// el ángulo en que el color del cielo en el horizonte se entremezcla con el color del cielo en su parte superior.
        /// </summary>
        public float AnguloCielo
        {
            get { return anguloCielo; }
            set { anguloCielo = value; }
        }        

        #endregion Metodos Get y Set C#

        public override string ToString()
        {
            String codigo;
            codigo = " groundAngle [" + (anguloSuelo*Math.PI)/180 + "] groundColor [" + colorSueloHorizonte.R / 255f + " " + colorSueloHorizonte.G / 255f + " " + colorSueloHorizonte.B / 255f +
            "- " + colorSueloEsfera.R / 255f + " " + colorSueloEsfera.G / 255f + " " + colorSueloEsfera.B / 255f + "] skyAngle [" + (anguloCielo*Math.PI)/180 + "] skyColor [" +
            colorCieloHorizonte.R / 255f + " " + colorCieloHorizonte.G / 255f + " " + colorCieloHorizonte.B / 255f + "- " + colorCieloEsfera.R / 255f + " " + colorCieloEsfera.G / 255f + " " + colorCieloEsfera.B / 255f + "] ";
            codigo = codigo.Replace(",", ".");
            codigo = codigo.Replace("-", ",");
            return codigo;
        }
    }
}

/*
 Sólo se emplea el primer nodo Background que se encuentre, debiéndose especificar en el archivo principal.
 Backgroud{  
    groundAngle     [ ]  
    groundColor     [ ]  
    skyAngle        [ ]  
    skyColor        [ ]  
    backUrl         "dirección_URL"  
    bottomURL       "dirección_URL"  
    frontUrl        "dirección_URL"  
    leftUrl         "dirección_URL"  
    rightUrl        "dirección_URL"  
    topUrl          "dirección_URL"  
}
     Todos estos campos no se utilizan simultaneamente, sino que su uso dependerá del tipo de fondo que se desee crear.
  

DEFINICION DE CIELO Y SUELO CON COLORES *********************  
El fondo de tipo Backdrop se construye mediante una esfera incompleta (el suelo) inmersa dentro de otra esfera completa (el cielo), en donde el visitante se situa en el centro de ambas. 
Estas esferas tienen un radio infinito.
 
Backgroud{  
    groundAngle     [.785]  
    groundColor     [ .14 .28 0,.09 .11 0 ]  
    skyAngle        [.785 ]  
    skyColor        [.02 0 .26, .02 0 .65 ]  
}  

El campo skyColor determina el color del cielo en los distintos ángulos de la esfera que lo contiene.
El primer valor de este campo determina el color del cielo en los 0.0 radianes de la esfera, es decir, el color que tiene el cielo en el lugar donde se une con el suelo.  

skyAngle: es utilizado para indicar los ángulos (en radianes) en los que un nuevo color debe aparecer. 
skyColor: debe poseer N+1 colores si en skyAngle se han definido N ángulos, ya que el ángulo 0.0 (que es el que se corresponde con el cielo del horizonte) no se incluye en este último.  

groundColor y groundAngle: son equivalentes a skyColor y skyAngle respectivamente, pero referidos a la esfera que representa el suelo.  
Si se especifica más de un color, se interpolará el color del suelo entre los colores de 0 a 90 grados en el horizonte (plano X-Z). 
De forma similar se interpretan los colores del cielo, de 90 a 180 grados en la vertical (plano X-Y).
 


Panorama ********

Sintaxis:  

Backgroud{  
    backUrl           "dirección_URL"  
    bottomURL     "dirección_URL"  
    frontUrl           "dirección_URL"  
    leftUrl              "dirección_URL"  
    rightUrl           "dirección_URL"  
    topUrl              "dirección_URL"  
}
 
de las cuales ocupa una de las caras de una inmensa caja centrada en el eje de coordenadas. 
Las imágenes que ocupan cada una de las caras vendrán determinadas por los valores de los campos backUrl, bottomUrl, frontUrl, leftUrl, rightUrl, topUrl. 
Todos estos campos toman como valor una dirección URL de un fichero que contiene una imágen en formato jpeg, gif o png 
  
CONVERSION DE GRADOS A RADIANES. (GRADOS * PI) / 180 
 
 */
